<template>
  <t-dialog
    :visible="visible"
    :header="dialogTitle"
    :footer="false"
    width="650px"
    class="import-dialog"
  >
    <div class="import-container">
      <!-- 文本导入 -->
      <div v-if="importType === 'text'" class="text-import">
        <t-textarea
          v-model="importState.textContent"
          :placeholder="importState.textPlaceholder"
          :autosize="{ minRows: 15, maxRows: 30 }"
        />
      </div>

      <!-- Excel导入 -->
      <div v-else-if="importType === 'excel'" class="excel-import">
        <div v-if="!importState.excelData" class="file-upload-area">
          <div class="excel-file-selector">
            <t-button @click="selectExcelFile">选择Excel文件</t-button>
            <p class="tip">支持 .xlsx, .xls 格式</p>
          </div>
        </div>

        <div v-else class="excel-preview">
          <div class="column-selection">
            <div class="selection-row">
              <div class="selection-label">标题列:</div>
              <t-select v-model="importState.titleColumnIndex" placeholder="选择标题列">
                <t-option
                  v-for="(column, index) in importState.headers"
                  :key="index"
                  :value="index"
                  :label="column || `列 ${index + 1}`"
                />
              </t-select>
            </div>
            <div class="selection-row">
              <div class="selection-label">内容列:</div>
              <t-select v-model="importState.contentColumnIndex" placeholder="选择内容列">
                <t-option
                  v-for="(column, index) in importState.headers"
                  :key="index"
                  :value="index"
                  :label="column || `列 ${index + 1}`"
                />
              </t-select>
            </div>
          </div>

          <div class="preview-table">
            <t-table
              :data="importState.previewData"
              row-key="index"
              :max-height="300"
              bordered
              stripe
            >
              <t-thead>
                <t-tr>
                  <t-th v-for="(header, index) in importState.headers" :key="index">
                    {{ header || `列 ${index + 1}` }}
                  </t-th>
                </t-tr>
              </t-thead>
              <t-tbody>
                <t-tr v-for="(row, rowIndex) in importState.previewData" :key="rowIndex">
                  <t-td v-for="(_, colIndex) in importState.headers" :key="colIndex">
                    {{ row[colIndex] }}
                  </t-td>
                </t-tr>
              </t-tbody>
            </t-table>
          </div>
        </div>
      </div>

      <!-- 批量音频导入 -->
      <div v-else-if="importType === 'batchAudio'" class="batch-audio-import">
        <div class="audio-upload-area">
          <div class="audio-selection-tip">已选择 {{ importState.audioFiles.length }} 个音频文件</div>
          <t-button @click="selectAudioFiles">选择音频文件</t-button>

          <div v-if="importState.audioFiles.length > 0" class="audio-files-list">
            <t-table
              :data="importState.audioFiles"
              row-key="path"
              :max-height="300"
              bordered
              stripe
            >
              <t-thead>
                <t-tr>
                  <t-th>文件名</t-th>
                  <t-th>时长</t-th>
                  <t-th>操作</t-th>
                </t-tr>
              </t-thead>
              <t-tbody>
                <t-tr v-for="(file, index) in importState.audioFiles" :key="index">
                  <t-td>{{ file.name }}</t-td>
                  <t-td>{{ file.duration || '获取中...' }}</t-td>
                  <t-td>
                    <t-button
                      variant="text"
                      theme="danger"
                      size="small"
                      @click="removeAudioFile(index)"
                    >
                      <template #icon>
                        <DeleteIcon />
                      </template>
                    </t-button>
                  </t-td>
                </t-tr>
              </t-tbody>
            </t-table>
          </div>
        </div>
      </div>

      <!-- 单个音频导入 UI 保持不变，直接调用 action.importAudio -->
    </div>

    <div class="dialog-footer">
      <t-space>
        <t-button theme="default" @click="closeDialog">取消</t-button>
        <t-button theme="primary" :loading="importState.importing" @click="handleImport">导入</t-button>
      </t-space>
    </div>
  </t-dialog>
</template>

<script setup>
import { ref, reactive, computed, watch } from 'vue';
import { MessagePlugin } from 'tdesign-vue-next';
import { DeleteIcon } from 'tdesign-icons-vue-next';
import { v4 as uuidv4 } from 'uuid';
import { Client } from '@renderer/client';
import { millisecondsToTime } from '@renderer/utils';

const props = defineProps({
  visible: {
    type: Boolean,
    default: false
  },
  importType: {
    type: String,
    default: 'text',
    validator: (value) => ['text', 'audio', 'excel', 'batchAudio'].includes(value)
  }
});

const emit = defineEmits(['update:visible', 'import', 'cancel']);

// 导入状态对象
const importState = reactive({
  // 文本导入相关
  textContent: '',
  textPlaceholder: '请输入要导入的文本内容，导入多篇，请使用 “---文章1---” 分割',

  // Excel导入相关
  file: null,
  excelData: null,
  headers: [],
  previewData: [],
  titleColumnIndex: null,
  contentColumnIndex: null,

  // 音频导入相关
  audioFiles: [],

  // 通用状态
  importing: false,
});

// 计算属性：对话框标题
const dialogTitle = computed(() => {
  switch (props.importType) {
    case 'text':
      return '导入文本';
    case 'excel':
      return '导入Excel文件';
    case 'audio':
      return '导入音频';
    case 'batchAudio':
      return '批量导入音频';
    default:
      return '导入内容';
  }
});

// 监听importType变化，重置状态
watch(() => props.importType, () => {
  resetState();
});

// 监听visible变化，重置状态
watch(() => props.visible, (newVisible) => {
  if (!newVisible) {
    resetState();
  }
});

// 重置状态
const resetState = () => {
  importState.textContent = '';
  importState.file = null;
  importState.excelData = null;
  importState.headers = [];
  importState.previewData = [];
  importState.titleColumnIndex = null;
  importState.contentColumnIndex = null;
  importState.audioFiles = [];
  importState.importing = false;
};

// 选择Excel文件
const selectExcelFile = async () => {
  try {
    // 使用Client.file.selectExcel方法
    const filePath = await Client.file.selectExcel();

    if (!filePath) return;

    // 显示加载提示
    MessagePlugin.loading('正在读取Excel文件...');

    try {
      // 读取Excel文件
      // 首先需要引入XLSX库
      const XLSX = await import('xlsx');

      // 使用更新后的readFileBuffer方法读取文件
      const buffer = await Client.file.readFileBuffer(filePath);

      // 解析Excel文件
      const data = new Uint8Array(buffer);
      const workbook = XLSX.read(data, { type: 'array' });

      // 获取第一个工作表
      const firstSheetName = workbook.SheetNames[0];
      const worksheet = workbook.Sheets[firstSheetName];

      // 转换为JSON
      const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });

      if (jsonData.length === 0) {
        MessagePlugin.warning('Excel文件为空');
        return;
      }

      // 提取表头和数据
      const headers = jsonData[0];
      const previewData = jsonData.slice(1, Math.min(6, jsonData.length)); // 取前5行作为预览

      // 更新状态
      importState.excelData = jsonData;
      importState.headers = headers;
      importState.previewData = previewData;

      // 提示用户选择列
      findTitleContentColumns(headers);

      MessagePlugin.success('Excel文件读取成功');
    } catch (error) {
      console.error('解析Excel文件失败:', error);
      MessagePlugin.error('解析Excel文件失败: ' + (error.message || '未知错误'));
    }
  } catch (error) {
    console.error('选择Excel文件失败:', error);
    MessagePlugin.error('选择Excel文件失败: ' + (error.message || '未知错误'));
  }
};

const findTitleContentColumns = (headers) => {
  // 如果未传入 headers 或数组为空，则直接返回
  if (!headers || headers.length === 0) return;

  // 定义匹配标题和内容的关键词列表
  const titleKeywords = ['标题', 'title', '名称', 'name', '主题', 'subject'];
  const contentKeywords = ['内容', 'content', '正文', 'body', '描述', 'description', 'text'];

  // 初始化变量，用于记录匹配到的标题和内容列索引，默认值为 -1 表示未匹配到
  let titleIndex = -1;
  let contentIndex = -1;

  // 遍历 headers，依次检查每个表头是否包含任一关键词
  headers.forEach((header, index) => {
    // 标题列：优先匹配 titleKeywords 中的任一关键词
    if (titleIndex === -1 && titleKeywords.some(keyword => header.toLowerCase().includes(keyword.toLowerCase()))) {
      titleIndex = index;
    }
    // 内容列：优先匹配 contentKeywords 中的任一关键词
    if (contentIndex === -1 && contentKeywords.some(keyword => header.toLowerCase().includes(keyword.toLowerCase()))) {
      contentIndex = index;
    }
  });

  // 当没有通过关键词匹配到有效列时，采用默认策略：
  // 将第一列作为标题列，第二列作为内容列（如果存在）
  if (titleIndex === -1 && headers.length > 0) {
    titleIndex = 0;
  }
  if (contentIndex === -1 && headers.length > 1) {
    contentIndex = 1;
  }

  // 根据匹配结果或默认值，为用户生成推荐的列提示
  importState.titleColumnIndex = `建议选择: ${headers[titleIndex] || `第${titleIndex + 1}列`}`;
  importState.contentColumnIndex = `建议选择: ${headers[contentIndex] || `第${contentIndex + 1}列`}`;

  // 通过消息插件向用户提示推荐选项
  if (headers.length > 1) {
    MessagePlugin.info(`请选择标题列和内容列，已为您预设推荐选项`, 5000);
  }
};

// 批量音频导入相关方法
const selectAudioFiles = async () => {
  try {
    // 使用selectMultipleAudio选择多个音频文件
    const filePaths = await Client.file.selectMultipleAudio({
      name: 'Audios',
      extensions: ['mp3', 'wav', 'flac', 'm4a']
    });

    if (!filePaths || filePaths.length === 0) return;

    // 显示加载中提示
    const loadingMsg = MessagePlugin.loading('正在处理音频文件...');

    // 为每个文件获取音频信息
    for (const filePath of filePaths) {
      try {
        const info = await Client.file.getAudioInfo(filePath);

        // 验证音频
        if (checkAudio(info)) {
          importState.audioFiles.push({
            id: uuidv4(),
            path: filePath,
            name: info.name || filePath.split(/[/\\]/).pop() || '未命名音频',
            duration: millisecondsToTime(info.duration * 1000),
            info: info
          });
        }
      } catch (err) {
        console.error('解析音频信息失败', err);
        MessagePlugin.error('解析音频文件失败: ' + filePath);
      }
    }

    if (importState.audioFiles.length > 0) {
      MessagePlugin.success(`已选择 ${importState.audioFiles.length} 个音频文件`);
    }
  } catch (error) {
    console.error('选择音频文件失败', error);
    MessagePlugin.error('选择音频文件失败：' + (error.message || '未知错误'));
  }
};

// 验证音频
const checkAudio = (audioInfo) => {
  if (!audioInfo.isOK) {
    MessagePlugin.error(audioInfo.msg || '音频上传失败');
    return false;
  }
  if (audioInfo.duration > 60 * 30) {
    MessagePlugin.error('音频时长不能超过30分钟');
    return false;
  }
  return true;
};

// 移除音频文件
const removeAudioFile = (index) => {
  importState.audioFiles.splice(index, 1);
};

// 处理导入操作
const handleImport = async () => {
  importState.importing = true;

  try {
    switch (props.importType) {
      case 'text':
        await handleTextImport();
        break;
      case 'excel':
        await handleExcelImport();
        break;
      case 'batchAudio':
        await handleBatchAudioImport();
        break;
      case 'audio':
        // 单个音频导入由父组件处理
        closeDialog();
        emit('import', { type: 'audio' });
        break;
    }
  } catch (error) {
    console.error('导入失败:', error);
    MessagePlugin.error('导入失败: ' + (error.message || '未知错误'));
  } finally {
    importState.importing = false;
  }
};

// 文本导入处理
const handleTextImport = async () => {
  const text = importState.textContent.trim();

  if (!text) {
    MessagePlugin.warning('请输入有效的文本内容');
    return;
  }

  const textParts = parseTextContent(text);

  if (textParts.length === 0) {
    MessagePlugin.warning('未找到有效的文本内容');
    return;
  }

  const textItems = textParts.map(part => ({
    id: uuidv4(),
    type: 'text',
    name: part.title,
    text: part.content,
    synthesizing: false,
    audioUrl: null,
    duration: null,
    createdAt: new Date().toISOString(),
  }));

  emit('import', { type: 'text', items: textItems });
  MessagePlugin.success('成功导入文本');
  closeDialog();
};

// Excel导入处理
const handleExcelImport = async () => {
  if (!importState.excelData) {
    MessagePlugin.warning('请先上传Excel文件');
    return;
  }

  if (importState.titleColumnIndex === null || importState.contentColumnIndex === null) {
    MessagePlugin.warning('请选择标题列和内容列');
    return;
  }

  // 跳过表头行，处理所有数据行
  const dataRows = importState.excelData.slice(1);
  const textItems = [];

  for (const row of dataRows) {
    // 检查数据行是否有效
    if (!row || row.length === 0) continue;

    const title = row[importState.titleColumnIndex] || '未命名';
    const content = row[importState.contentColumnIndex];

    // 只有内容不为空的才添加
    if (content) {
      textItems.push({
        id: uuidv4(),
        type: 'text',
        name: String(title),
        text: String(content),
        synthesizing: false,
        audioUrl: null,
        duration: null,
        createdAt: new Date().toISOString(),
      });
    }
  }

  if (textItems.length === 0) {
    MessagePlugin.warning('未找到有效的内容');
    return;
  }

  emit('import', { type: 'text', items: textItems });
  MessagePlugin.success(`成功导入 ${textItems.length} 篇文章`);
  closeDialog();
};

// 批量音频导入处理
const handleBatchAudioImport = async () => {
  if (importState.audioFiles.length === 0) {
    MessagePlugin.warning('请先选择音频文件');
    return;
  }

  const audioItems = importState.audioFiles.map(file => ({
    id: uuidv4(),
    type: 'audio',
    name: file.name,
    audioUrl: file.path,
    duration: file.duration,
    createdAt: new Date().toISOString(),
  }));

  emit('import', { type: 'audio', items: audioItems });
  MessagePlugin.success(`成功导入 ${audioItems.length} 个音频文件`);
  closeDialog();
};

// 解析文本内容，处理 ---xxx--- 格式
const parseTextContent = (text) => {
  // 检查是否包含 ---xxx--- 格式的分隔符
  if (text.match(/^---.*---$/m)) {
    // 使用正则表达式分割文本
    const pattern = /(^|\n)---(.*?)---\s*\n/g;
    const parts = text.split(pattern).filter(part => part.trim() && !part.match(/^---.*---$/));

    // 将分割后的文本和标题组合起来
    const result = [];
    for (let i = 0; i < parts.length; i += 2) {
      const title = parts[i].trim();
      const content = (i + 1 < parts.length) ? parts[i + 1].trim() : '';

      if (content) {
        result.push({
          title: title,
          content: content
        });
      }
    }

    return result;
  } else {
    // 如果没有找到分隔符，则按行分割
    return text.split('\n')
      .map(line => line.trim())
      .filter(line => line.length > 0)
      .map(line => ({
        title: line.substring(0, 20) + (line.length > 20 ? '...' : ''),
        content: line
      }));
  }
};

// 关闭对话框
const closeDialog = () => {
  resetState();
  emit('update:visible', false);
  emit('cancel');
};
</script>

<style scoped>
.import-container {
  padding: 20px 0;
}

.file-upload-area, .audio-upload-area {
  margin-bottom: 20px;
  display: flex;
  flex-direction: column;
  align-items: center;
  padding: 20px;
  border: 2px dashed #dcdcdc;
  border-radius: 8px;
  background-color: #f9f9f9;
}

.excel-file-selector {
  display: flex;
  flex-direction: column;
  align-items: center;
}

.tip {
  font-size: 12px;
  color: rgba(0, 0, 0, 0.6);
  margin-top: 8px;
}

.column-selection {
  margin-bottom: 20px;
}

.selection-row {
  display: flex;
  align-items: center;
  margin-bottom: 12px;
}

.selection-label {
  width: 80px;
  margin-right: 12px;
}

.preview-table {
  margin-top: 20px;
}

.audio-selection-tip {
  margin-bottom: 12px;
  font-size: 14px;
  color: #666;
}

.audio-files-list {
  margin-top: 20px;
  width: 100%;
}

.dialog-footer {
  display: flex;
  justify-content: center;
  margin-top: 24px;
}
</style>
